#!/bin/bash
#Nombre del archivo: Recibir_B
#       Descripcion: es el script encargado de detectar el arribo de archivos de reservas al sistema "RESER_B".

#El proposito de este comando es detectar la llegada de archivos al directorio "$ARRIDIR", efectuar la validacion del nombre del archivo que detecta y ponerlo a disposicion del siguiente paso.
#Es el segundo en orden de ejecucion.
#Es un proceso del tipo “demonio”: Se dispara automaticamente o a traves de "Start_D" y se detiene a traves de "Stop_D".
#Graba en el archivo de log a traves de "Grabar_L".
#Invoca, si corresponde, al siguiente paso: "Reservar_B".
#Cada empresario o productor envia archivos solicitando reservas para cierto evento o listados con los nombres de los invitados.
#Si el nombre del archivo (filename) es del tipo esperado, acepta el archivo, de lo contrario, lo rechaza.
#Tambien en el caso de contar con archivos de reservas solicitadas “aceptadas”, arranca "Reservar_B" para que las confirme.

#Se puede ingresar un unico parametro, que es opcional, y que sera el tiempo de intervalo (en segundos). Este parametro, de ingresarse, debe ser un valor numerico.



#ESTO ES SOLO PARA DEPURAR EL PROGRAMA, QUITAR PARA LA INTEGRACION:
#declare EJECUTADOEN="/home/kubuntu/Documents/0prueba/grupo06/bin";
#Declaro las variables necesarias para poder probrar este script:
#declare -x ACEPDIR=${EJECUTADOEN}/../aceptados;
#declare -x ARRIDIR=${EJECUTADOEN}/../arribos;
#declare -x BINDIR=${EJECUTADOEN}/../bin;
#declare -x MAEDIR=${EJECUTADOEN}/../mae;
#declare -x RECHDIR=${EJECUTADOEN}/../rechazados;
#declare -x REPODIR=${EJECUTADOEN}/../listados;

declare -x OBRAS_ARCHIVO_NOMBRE="obras.mae";
declare -x SALAS_ARCHIVO_NOMBRE="salas.mae";

#Declaro las variables necesarias para poder usar "Grabar_L":
#declare -x LOGDIR=${EJECUTADOEN}/../log;
#declare -x LOGEXT=.log;
#declare -x LOGSIZE=400;



: <<'VERIFICAR'
Se encarga de realizar las comparaciones de direcciones de correo electrónico, teniendo en cuenta si se trata de una reserva por obra o por sala. Devuelve "1" si coinciden las direcciones de correo electronico, "0" en caso contrario.
VERIFICAR
function VERIFICAR {
	case ${1} in
	"OBRA")
		#echo "Verifico ${REGISTRO[1]} == ${!RESERVAS_CORREO}";
		#echo "Verifico ${REGISTRO[2]} == ${!RESERVAS_CORREO}";
		if [[ ("${REGISTRO[1]}" == "${!RESERVAS_CORREO}") || ("${REGISTRO[2]}" == "${!RESERVAS_CORREO}") ]];
		then
			return 1;
		else
			return 0;
		fi;
		;;
	"SALA")
		#echo "Verifico ${REGISTRO[1]} == ${!RESERVAS_CORREO}";
		if [[ "${REGISTRO[1]}" == "${!RESERVAS_CORREO}" ]];
		then
			return 1;
		else
			return 0;
		fi;
		;;
	*)
		return 2;
		;;
	esac;
}


: <<'LOGGEADOR'
Se encarga de loggear los mensajes forma inteligente.
LOGGEADOR
function LOGGEADOR {
	"${LOGGER}" "${NOMBRE_PROGRAMA}" "${1}" "${2}";
	if [[ ${?} != 0 ]];
	then
		echo "ERROR: No se pudo grabar con \"${LOGGER}\".";
		echo "El mensaje era: ${2}";
	fi;
}


: <<'MOVEDOR'
Se encarga de mover los archivos en forma inteligente.
MOVEDOR
function MOVEDOR {
	if [[ ${#} == 2 ]];
	then
		"${MOVER}" "${1}" "${2}";
	else
		"${MOVER}" "${1}" "${2}" "${3}";
		if [[ ${?} != 0 ]];
		then
			LOGGEADOR "E" "ERROR: No se pudo mover con \"${MOVER}\". Se queria mover \"${1}\" a \"${2}\".";
		fi;
	fi;
}


#Este script (y los scripts que lanza) necesita las variables ACEPDIR, ARRIDIR, BINDIR, MAEDIR, RECHDIR, REPODIR, OBRAS_ARCHIVO_NOMBRE, SALAS_ARCHIVO_NOMBRE, LOGDIR, LOGEXT, y LOGSIZE.
declare -r VARIABLES_NECESARIAS=(ACEPDIR ARRIDIR BINDIR MAEDIR RECHDIR REPODIR OBRAS_ARCHIVO_NOMBRE SALAS_ARCHIVO_NOMBRE LOGDIR LOGEXT LOGSIZE);

#Este script (y los scripts que lanza) necesita los directorios ACEPDIR, ARRIDIR, BINDIR, MAEDIR, RECHDIR, REPODIR, y LOGDIR.
declare -r DIRECTORIOS_NECESARIOS=(ACEPDIR ARRIDIR BINDIR MAEDIR RECHDIR REPODIR LOGDIR);
declare -r DIRECTORIOS_NECESARIOS_R=(ACEPDIR ARRIDIR BINDIR MAEDIR RECHDIR REPODIR LOGDIR);
declare -r DIRECTORIOS_NECESARIOS_W=(ACEPDIR ARRIDIR RECHDIR REPODIR LOGDIR);
declare -r DIRECTORIOS_NECESARIOS_X=(ACEPDIR ARRIDIR BINDIR MAEDIR RECHDIR REPODIR LOGDIR);

#Este script (y los scripts que lanza) necesita los archivos OBRAS_ARCHIVO y SALAS_ARCHIVO.
declare -r ARCHIVOS_NECESARIOS=(OBRAS_ARCHIVO SALAS_ARCHIVO LOGGER MOVER RESERVAR_B);
declare -r ARCHIVOS_NECESARIOS_R=(OBRAS_ARCHIVO SALAS_ARCHIVO LOGGER MOVER RESERVAR_B);
declare -r ARCHIVOS_NECESARIOS_X=(LOGGER MOVER RESERVAR_B);

#Declaro la constante que indica el tiempo estandar de intervalo (en segundos).
declare -r INTERVALO_ESTANDAR_SEGUNDOS="10";
#Declaro la constante que indica la ruta al archivo maestro de obras.
declare -r OBRAS_ARCHIVO="${MAEDIR}/${OBRAS_ARCHIVO_NOMBRE}";
#Declaro la constante que indica la ruta al archivo maestro de salas.
declare -r SALAS_ARCHIVO="${MAEDIR}/${SALAS_ARCHIVO_NOMBRE}";
#Declaro la constante que indica la ruta al script que hace el logging.
declare -r LOGGER="${BINDIR}/Grabar_L";
#Declaro la constante que indica la ruta al script que hace el movimiento de archivos.
declare -r MOVER="${BINDIR}/Mover_B";
#Declaro la constante que indica el nombre del archivo correspondiente al script "Reservar_B" (lo necesito para buscarlo en la tabla de procesos).
declare -r RESERVAR_B_ARCHIVO="Reservar_B";
#Declaro la constante que indica la ruta al script Reservar_B.
declare -r RESERVAR_B="${BINDIR}/${RESERVAR_B_ARCHIVO}";
#Declaro la constante que indica el nombre con el que este programa ingresa mensajes en el archivo de log.
declare -r NOMBRE_PROGRAMA="Recibir_B";


#No se puede ejecutar este comando si la inicializacion de ambiente no fue realizada.
#Chequeo las variables que se necesitan (tanto en este script como en el script "Reservar_B", que es invocado desde este script).
#Me fijo que esten asignadas. "-o" significa "OR"; y "-z" siginifica que no sea una cadena de largo igual a cero; la expansion pone una cadena de largo igual a cero si no esta definida la variable.
for ITERADOR in ${VARIABLES_NECESARIAS[*]};
do
	TEMP="${!ITERADOR}";
	if [ -z "${TEMP:-}" ];
	then
		echo "ERROR: No se puede ejecutar \"${NOMBRE_PROGRAMA}\" si la inicializacion de ambiente no fue realizada.";
		echo "ERROR: No existe la variable de entorno: \"${ITERADOR}\"." ;
		exit 1;
	fi;
done;
#Mejora: hacer de esto un script extra.

#Chequeo que existan los directorios necesarios.
for ITERADOR in ${DIRECTORIOS_NECESARIOS[*]};
do
	if [ ! -d "${!ITERADOR}" ];
	then
		echo "ERROR: No existe el directorio: \"${!ITERADOR}\"." ;
		exit 2;
	fi;
done;
#Mejora: hacer de esto un script extra.

#Chequeo que los directorios necesarios tengan el permiso de lectura.
for ITERADOR in ${DIRECTORIOS_NECESARIOS_R[*]};
do
	if [ ! -r "${!ITERADOR}" ];
	then
		echo "ERROR: No esta pemitido leer el directorio: \"${!ITERADOR}\"." ;
		exit 3;
	fi;
done;
#Mejora: hacer de esto un script extra.

#Chequeo que los directorios necesarios tengan el permiso de escritura.
for ITERADOR in ${DIRECTORIOS_NECESARIOS_W[*]};
do
	if [ ! -w "${!ITERADOR}" ];
	then
		echo "ERROR: No esta pemitido escribir el directorio: \"${!ITERADOR}\"." ;
		exit 4;
	fi;
done;
#Mejora: hacer de esto un script extra.

#Chequeo que los directorios necesarios tengan el permiso de ejecucion.
for ITERADOR in ${DIRECTORIOS_NECESARIOS_X[*]};
do
	if [ ! -x "${!ITERADOR}" ];
	then
		echo "ERROR: No esta pemitido ejecutar el directorio: \"${!ITERADOR}\"." ;
		exit 5;
	fi;
done;
#Mejora: hacer de esto un script extra.

#Chequeo que existan los archivos necesarios.
for ITERADOR in ${ARCHIVOS_NECESARIOS[*]};
do
	if [ ! -e "${!ITERADOR}" ];
	then
		echo "ERROR: No existe el archivo: \"${!ITERADOR}\"." ;
		exit 6;
	fi;
done;
#Mejora: hacer de esto un script extra.

#Chequeo que los archivos necesarios tengan el permiso de lectura.
for ITERADOR in ${ARCHIVOS_NECESARIOS_R[*]};
do
	if [ ! -r "${!ITERADOR}" ];
	then
		echo "ERROR: No esta pemitido leer el archivo: \"${!ITERADOR}\"." ;
		exit 7;
	fi;
done;
#Mejora: hacer de esto un script extra.

#Chequeo que los archivos necesarios tengan el permiso de ejecucion.
for ITERADOR in ${ARCHIVOS_NECESARIOS_X[*]};
do
	if [ ! -x "${!ITERADOR}" ];
	then
		echo "ERROR: No esta pemitido ejecutar el archivo: \"${!ITERADOR}\"." ;
		exit 8;
	fi;
done;
#Mejora: hacer de esto un script extra.

#En el enunciado se pide que la variable que almacena el valor del intervalo se llame "x".
if [[ "${#}" -gt 1 ]];
then
	echo 'ERROR: Solo se puede ingresar un unico parametro, que es opcional, y que sera el tiempo de intervalo (en segundos).';
	exit 9;
else
	if [[ "${#}" -eq 1 ]];
	then
		if [[ "${1}" != *[!0-9]* ]];
		then
			x="${1}";
		else
			echo "ERROR: Solo se puede ingresar un unico parametro, que es opcional, y que sera el tiempo de intervalo (en segundos), y debe estar compuesto exclusivamente por numeros, Ud. ingreso: \"$1\".";
			exit 10;
		fi;
	else
		x="$INTERVALO_ESTANDAR_SEGUNDOS";
	fi;
fi;


#Declaro estas variables aca afuera de los ciclos para que no se re-declaren al iterar.
NRO_CICLO=0;
declare -r ARCHIVO_OBRA_CAMPOS='{ print $1, $3, $4 }';
declare -r ARCHIVO_SALA_CAMPOS='{ print $1, $6 }';
declare -r ARREGLO_OBRA_CAMPOS='{ print $1, $2, $3 }';
declare -r ARREGLO_SALA_CAMPOS='{ print $1, $2 }';

#El ciclo infinito del "daemon".
while ( true );
do
	#Grabar el registro de ejecucion.
	LOGGEADOR "I" "Ciclo Nro. $[++NRO_CICLO]";

	#Modifico la variable de bash "IFS", para poder iterar en un "for-loop" de bash, a traves de las entradas provenientes de una lista cuyo separador es el salto de linea y que puede contener uno o más espacios dentro de sus registros.
	IFS_BACKUP=${IFS};
	IFS=$'\n';

	RESERVAS_POR_OBRA_CANTIDAD=0;
	RESERVAS_POR_SALA_CANTIDAD=0;

	#Un ciclo para recorrer uno por uno los archivos del directorio de arribos.
	for ARCHIVO_NOMBRE in $(ls "-1" "-v" "-p" "${ARRIDIR}" | grep '[^/]$');
	do
		#Veo si es un archivo de texto.
		if [[ $(file --mime-type "${ARRIDIR}/${ARCHIVO_NOMBRE}" | grep -c "text" -) == 0 ]];
		#revisar el valor de $? de file.
		then
			#No es un archivo de texto.
			#echo "\"${ARRIDIR}/${ARCHIVO_NOMBRE}\""$'\t'"no es un archivo de texto.";
			LOGGEADOR "I" "\"${ARRIDIR}/${ARCHIVO_NOMBRE}\""$'\t'"no es un archivo de texto.";
			MOVEDOR "${ARRIDIR}/${ARCHIVO_NOMBRE}" "${RECHDIR}/${ARCHIVO_NOMBRE}" "${NOMBRE_PROGRAMA}";
		else
			#Ver si es un archivo de invitados.
			if [[ ${ARCHIVO_NOMBRE} == +([!- ]).inv ]];
			then
				#Es un archivo de invitados.
				#echo "\"${ARRIDIR}/${ARCHIVO_NOMBRE}\""$'\t'"es un archivo de invitados.";
				LOGGEADOR "I" "\"${ARRIDIR}/${ARCHIVO_NOMBRE}\""$'\t'"es un archivo de invitados.";
				MOVEDOR "${ARRIDIR}/${ARCHIVO_NOMBRE}" "${REPODIR}/${ARCHIVO_NOMBRE}" "${NOMBRE_PROGRAMA}";
			else
				#No es un archivo de invitados, ver si es archivo de reservas.
				if [[ ${ARCHIVO_NOMBRE} == +([0-9])-+([! @])@+([! .@])+(.+([! .@]))-*([!- ]) ]];
				#Uno o mas digitos,
				#seguidos de un caracter '-',
				
				#seguido de una direccion de correo compuesta por:
				#al menos un caracter del conjunto de caracteres distintos del espacio y '@',
				#un caracter '@',
				#al menos un caracter del conjunto de caracteres distintos del espacio, el punto, y '@',
				#al menos un conjunto de:
					#un caracter '.',
					#al menos un caracter del conjunto de caracteres distintos del espacio, el punto, y '@',
				
				#seguida de un caracter '-'
				#y terminando en cualquier cadena (incluyendo la cadena nula) que no contenga ninguna ocurrencia de los caracteres '-' y espacio.
				#Mejora: esto no rechaza una direccion de correo que termine en un punto.
				then
					#Es un archivo de reservas, ver si es por obra o por sala.
					IFS=${IFS_BACKUP};
					RESERVA=($(echo ${ARCHIVO_NOMBRE} | awk 'BEGIN { FS="-" } { print $1, $2 }'));
					#echo "\"${ARRIDIR}/${ARCHIVO_NOMBRE}\""$'\t'"es un archivo de reservas.";
					#echo "RESERVA = ${RESERVA[*]}"$'\t\t'"RESERVA_ID = ${RESERVA[0]}"$'\t\t'"RESERVA_CORREO = ${RESERVA[1]}";
					#Los ids impares son para las obras, los pares para las salas.
					if [[ ${RESERVA[0]}%2 -eq 1 ]];
					then
						#Es un archivo de reservas por obra.
						TIPO="OBRA";
					else
						#Es un archivo de reservas por sala.
						TIPO="SALA";
					fi;
					#Cargar en vector para despues ver si es válido
					declare RESERVAS_POR_${TIPO}_ID[RESERVAS_POR_${TIPO}_CANTIDAD]=${RESERVA[0]};
					declare RESERVAS_POR_${TIPO}_CORREO[RESERVAS_POR_${TIPO}_CANTIDAD]=${RESERVA[1]};
					declare RESERVAS_POR_${TIPO}_ARCHIVO[RESERVAS_POR_${TIPO}_CANTIDAD]=$ARCHIVO_NOMBRE;
					((++RESERVAS_POR_${TIPO}_CANTIDAD));
				else
					#Es un archivo de de texto con formato de nombre invalido.
					#echo "\"${ARRIDIR}/${ARCHIVO_NOMBRE}\""$'\t'"es un archivo de texto con formato de nombre invalido.";
					LOGGEADOR "I" "\"${ARRIDIR}/${ARCHIVO_NOMBRE}\""$'\t'"es un archivo de texto con formato de nombre invalido.";
					MOVEDOR "${ARRIDIR}/${ARCHIVO_NOMBRE}" "${RECHDIR}/${ARCHIVO_NOMBRE}" "${NOMBRE_PROGRAMA}";
				fi;
			fi;
		fi;
	done;
	IFS=${IFS_BACKUP};

	#Para procesar las reservas por obra y por sala.
	for TIPO in "OBRA" "SALA";
	do
		#Si hay reservas de ese tipo...
		if [[ RESERVAS_POR_${TIPO}_CANTIDAD -gt 0 ]];
		then
			#Para que no me diga que las direcciones de mail son distintas solo porque difieren entre mayusculas y minusculas.
			shopt -s nocasematch;
			RESERVAS_CONTADOR="0";
			RESERVAS_CANTIDAD="RESERVAS_POR_${TIPO}_CANTIDAD";
			ARCHIVO_NOMBRE="${TIPO}S_ARCHIVO_NOMBRE";
			RUTA="${MAEDIR}/${!ARCHIVO_NOMBRE}";
			RESERVAS_ID="RESERVAS_POR_${TIPO}_ID";
			RESERVAS_ID+="[RESERVAS_CONTADOR]";
			RESERVAS_CORREO="RESERVAS_POR_${TIPO}_CORREO";
			RESERVAS_CORREO+="[RESERVAS_CONTADOR]";
			RESERVAS_ARCHIVO="RESERVAS_POR_${TIPO}_ARCHIVO";
			RESERVAS_ARCHIVO+="[RESERVAS_CONTADOR]";
			declare ARCHIVO_CAMPOS="ARCHIVO_${TIPO}_CAMPOS";
			declare ARREGLO_CAMPOS="ARREGLO_${TIPO}_CAMPOS";
			IFS=$'\n';
			#Para cada registro del archivo maestro correspondiente.
			for REGISTRO in $(awk -F \; -v RS='[\r\n]+' "${!ARCHIVO_CAMPOS}" "${RUTA}" | sort -n);
			do
				IFS=${IFS_BACKUP};
				#Obtengo los campos que me interesan segun si es una reserva por obra o por sala.
				REGISTRO=($(echo ${REGISTRO} | awk 'BEGIN { FS=" " }'\ "${!ARREGLO_CAMPOS}"));


				#Mientras el id que estoy procesando es menor que el id del registro maestro que lei y me quedan reservas de este tipo por procesar...
				while [[ (${REGISTRO[0]} -gt ${!RESERVAS_ID}) && (${RESERVAS_CONTADOR} -lt ${!RESERVAS_CANTIDAD}) ]];
				do
					#echo "\"${ARRIDIR}/${!RESERVAS_ARCHIVO}\""$'\t'"no es un archivo valido de reservas solicitadas por ${TIPO}. Identificador invalido.";
					LOGGEADOR "I" "\"${ARRIDIR}/${!RESERVAS_ARCHIVO}\""$'\t'"no es un archivo valido de reservas solicitadas por ${TIPO}. Identificador invalido.";
					MOVEDOR "${ARRIDIR}/${!RESERVAS_ARCHIVO}" "${RECHDIR}/${!RESERVAS_ARCHIVO}" "${NOMBRE_PROGRAMA}";
					((++RESERVAS_CONTADOR));
				done;
				#Si salio del "while" porque no me quedaban mas reservas de este tipo por procesar...
				if [[ ${RESERVAS_CONTADOR} -ge ${!RESERVAS_CANTIDAD} ]]
				then
					#Salgo del "for" que iteraba por el archivo maestro.
					break;
				fi;


				#Mientras el id que estoy procesando es igual que el id del registro maestro que lei y me quedan reservas de este tipo por procesar...
				while [[ (${REGISTRO[0]} -eq ${!RESERVAS_ID}) && (${RESERVAS_CONTADOR} -lt ${!RESERVAS_CANTIDAD}) ]];
				do
					#Verifico si coinciden las direcciones de correo electronico, teniendo en cuenta el tipo de reserva que estoy procesando.
					VERIFICAR ${TIPO};
					#Si coinciden las direcciones de correo electronico de la reserva y del archivo maestro...
					if [[ $? -eq 1 ]]
					then
						#echo "\"${ARRIDIR}/${!RESERVAS_ARCHIVO}\""$'\t'"es un archivo de reservas solicitadas por ${TIPO}.";
						LOGGEADOR "I" "\"${ARRIDIR}/${!RESERVAS_ARCHIVO}\""$'\t'"es un archivo de reservas solicitadas por ${TIPO}.";
						MOVEDOR "${ARRIDIR}/${!RESERVAS_ARCHIVO}" "${ACEPDIR}/${!RESERVAS_ARCHIVO}" "${NOMBRE_PROGRAMA}";
					else
						#echo "\"${ARRIDIR}/${!RESERVAS_ARCHIVO}\""$'\t'"no es un archivo valido de reservas solicitadas por ${TIPO}. Direccion de correo invalida.";
						LOGGEADOR "I" "\"${ARRIDIR}/${!RESERVAS_ARCHIVO}\""$'\t'"no es un archivo valido de reservas solicitadas por ${TIPO}. Direccion de correo invalida.";
						MOVEDOR "${ARRIDIR}/${!RESERVAS_ARCHIVO}" "${RECHDIR}/${!RESERVAS_ARCHIVO}" "${NOMBRE_PROGRAMA}";
					fi;
					((++RESERVAS_CONTADOR));
				done;
				#Si salio del "while" porque no me quedaban mas reservas de este tipo por procesar...
				if [[ ${RESERVAS_CONTADOR} -ge ${!RESERVAS_CANTIDAD} ]]
				then
					#Salgo del "for" que iteraba por el archivo maestro.
					break;
				fi;


				#Si el id que estoy procesando es mayor que el id del registro maestro que lei...
				if [[ ${REGISTRO[0]} -lt ${!RESERVAS_ID} ]];
				then
					continue;
				fi;
			done;
			IFS="${IFS_BACKUP}";


			#Mientras me quedan reservas de este tipo por procesar...
			while [ ${RESERVAS_CONTADOR} -lt ${!RESERVAS_CANTIDAD} ];
			do
				#echo "\"${ARRIDIR}/${!RESERVAS_ARCHIVO}\""$'\t'"no es un archivo valido de reservas solicitadas por ${TIPO}. Identificador invalido.";
				LOGGEADOR "I" "\"${ARRIDIR}/${!RESERVAS_ARCHIVO}\""$'\t'"no es un archivo valido de reservas solicitadas por ${TIPO}. Identificador invalido.";
				MOVEDOR "${ARRIDIR}/${!RESERVAS_ARCHIVO}" "${RECHDIR}/${!RESERVAS_ARCHIVO}" "${NOMBRE_PROGRAMA}";
				((++RESERVAS_CONTADOR));
			done;
			shopt -u nocasematch;
		fi;
	done

	#Si hay archivos en el directorio de aceptados...
	if [[ -n $(ls "-1" "-p" "${ACEPDIR}" | grep '[^/]$') ]];
	then
		ESTA_EJECUTANDOSE=false;
		IFS=$'\n';
		#Veo si se esta ejecutando el script "Reservar_B".
		for PROCESO in $(ps -e | grep "${RESERVAR_B_ARCHIVO}" | awk '{ print $4 }');
		do
			if [[ "${PROCESO}" == "${RESERVAR_B_ARCHIVO}" ]];
			then
				ESTA_EJECUTANDOSE=true;
				LOGGEADOR "I" "${RESERVAR_B_ARCHIVO} ya se encuentra ejecutandose.";
			fi;
		done;
		#Si no se esta ejecutando el script "Reservar_B"...
		if ( ! $ESTA_EJECUTANDOSE );
		then
			#Lo lanzo en segundo plano.
			"${RESERVAR_B}" &
			for PROCESO in $(ps -e | grep "${RESERVAR_B_ARCHIVO}" | awk '{ print $1, $4 }');
			do
				IFS="${IFS_BACKUP}";
				PROCESO=($(echo ${PROCESO} | awk 'BEGIN { FS=" " } { print $1, $2 }'));
				if [[ "${PROCESO[1]}" == "${RESERVAR_B_ARCHIVO}" ]];
				then
					#Muestro por pantalla el "process id" del script "Reservar_B" que acabo de lanzar en segundo plano.
					echo "El \"process id\" de \"${RESERVAR_B_ARCHIVO}\" es: ${PROCESO[0]}.";
					LOGGEADOR "I" "${RESERVAR_B_ARCHIVO} fue lanzado con el \"process id\": ${PROCESO[0]}.";
				fi;
			done;
		fi;
		IFS="${IFS_BACKUP}";
	fi;

	#Duermo el proceso durante "x" segundos.
	sleep "${x}";
done;